home *** CD-ROM | disk | FTP | other *** search
/ Computer Inter@ctive 17 / Computer Interactive cdrom 17 - gen 99.iso / ZDNETIT / CONTENT / OPTIVDOS.ZIP / INCLUDE.ZIP / MFSTD.H < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-21  |  54.5 KB  |  1,039 lines
  1. /*  MFstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "float"
  5.   (single-precision real numbers)
  6.  
  7.   Copyright (c) 1996-1998 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MFSTD_H )
  12. #define __MFSTD_H
  13. #if !defined( __MATLIB_H )
  14. #include <MatLib.h>
  15. #endif
  16. #if !defined( __VFSTD_H )
  17. #include <VFstd.h>
  18. #endif
  19.  
  20. #ifdef __cplusplus
  21. extern "C" {
  22. #endif
  23.  
  24. /*************   Dynamic Generation of Matrices   ************************/
  25.  
  26. fMatrix __vf  MF_matrix(  unsigned ht, unsigned len );
  27. fMatrix __vf  MF_matrix0( unsigned ht, unsigned len );
  28.     /*  notice that, in the memory model HUGE,
  29.         neither len nor ht may exceed 8191            */
  30.  
  31. /***************************************************************************
  32.  *  The following definitions ensure compatibility between dynamically     *
  33.  *  and statically allocated matrices. The definitions are somewhat        *
  34.  *  cumbersome, but the result for you is that you need not care about     *
  35.  *  the differences between the two types.                                 *
  36.  *  (Internally, the address of the first element of any matrix is needed; *
  37.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  38.  *  but yields in either case the correct address to be passed to the      *
  39.  *  function you wish to call.)                                            *
  40.  *  Only in the rare case that you need to pass the address of one of      *
  41.  *  these functions as an argument to another function, you have to use    *
  42.  *  the actual run-time functions defined further below. Be careful with   *
  43.  *  this: future development of compilers may allow us to avoid this un-   *
  44.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  45.  *  use these run-time names.                                              *
  46.  ***************************************************************************/
  47.  
  48.  
  49. /***  Addressing single elements of dynamically allocated matrices: ******
  50.      These two functions are for compatibility with Pascal
  51.      (where elements of dynamically allocated matrices are not directly
  52.      accessible), and for getting around the pointer arithmetics bug in
  53.      some versions of Borland C++.                                         */
  54.  
  55. #define MF_Pelement( MA, ht, len, m, n ) MFPelement( MA[0], ht, len, m, n )
  56.                      /* returns a pointer to MA[m][n]. */
  57. #define MF_element( MA, ht, len, m, n ) (*MFPelement( MA[0], ht, len, m, n ))
  58.                      /* dereferenced pointer */
  59.  
  60.  /****************  Initialization  ***************************************
  61.  
  62.     To initialize all elements of a matrix with the same value,
  63.     or to perform arithmetic operations on all elements simultaneously,
  64.     refer to the functions of VectorLib, declared in <VFstd.h>, <VFmath.h>.
  65.     In order to use the VectorLib functions, utilize the feature that
  66.     the whole matrix occupies one contiguous area in memory: pass the
  67.     address of the first row to the desired vector function, the size
  68.     of the "vector" being ht * len.
  69.     For example, initialize all elements of the matrix MA with 1.0
  70.     (this is *NOT* the identity matrix)  by calling
  71.         VF_equ1( MA[0], ht * len );
  72. */
  73.  
  74. #define MF_equ0( MA, ht, len )            VF_equ0( MA[0], ((ui)ht)*len )
  75. #define MF_equ1( MA, len )                MFequ1( MA[0], len )
  76.                        /* this is the identity matrix */
  77. #define MF_outerprod( MA, X, Y, ht, len ) MFouterprod( MA[0], X, Y, ht, len )
  78.                        /* sizX=ht, sizY=len */
  79. #define MF_Row_equC( MA, ht, len, iRow, C ) \
  80.                                         MFRow_equC( MA[0], ht, len, iRow, C )
  81. #define MF_Col_equC( MA, ht, len, iCol, C ) \
  82.                                         MFCol_equC( MA[0], ht, len, iCol, C )
  83. #define MF_Dia_equC( MA, len, C )       MFDia_equC( MA[0], len, C )
  84.  
  85. #define MF_Row_equV( MA, ht, len, iRow, X ) \
  86.                                         MFRow_equV( MA[0], ht, len, iRow, X )
  87. #define MF_Col_equV( MA, ht, len, iCol, X ) \
  88.                                         MFCol_equV( MA[0], ht, len, iCol, X )
  89. #define MF_Dia_equV( MA, len, X )       MFDia_equV( MA[0], len, X )
  90.  
  91. #define MF_equM( MB, MA, ht, len )  VF_equV( MB[0], MA[0], (ui)(ht)*(len) )
  92.  
  93. #define MF_UequL( MA, len ) MFUequL( MA[0], len )
  94. #define MF_LequU( MA, len ) MFLequU( MA[0], len )
  95.          /* copy lower-diagonal elements into upper-diagonal
  96.            (or vice versa) by index-reflection, so as to
  97.            get a symmetric matrix    */
  98.  
  99.             /* data-type conversions:  */
  100. #define M_DtoF( MF, MD, ht, len ) V_DtoF( MF[0], MD[0], ((ui)ht)*len )
  101. #define M_EtoF( MF, ME, ht, len ) V_EtoF( MF[0], ME[0], ((ui)ht)*len )
  102. #define M_FtoD( MD, MF, ht, len ) V_FtoD( MD[0], MF[0], ((ui)ht)*len )
  103. #define M_FtoE( ME, MF, ht, len ) V_FtoE( ME[0], MF[0], ((ui)ht)*len )
  104.  
  105.             /* suitable windows for MF_spectrum: */
  106. #define MF_Hanning( MA, ht, len )  MFHanning( MA[0], ht, len )
  107. #define MF_Parzen( MA, ht, len )   MFParzen( MA[0], ht, len )
  108. #define MF_Welch( MA, ht, len )    MFWelch( MA[0], ht, len )
  109.  
  110. /********  Extracting a submatrix and copying a submatrix back  *********/
  111.  
  112. #define MF_submatrix( MSub, subHt, subLen, \
  113.                       MSrce, srceHt, srceLen, \
  114.                       firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  115.                MFsubmatrix(  MSub[0], subHt, subLen, \
  116.                              MSrce[0], srceHt, srceLen, \
  117.                              firstRowInCol, sampInCol, firstColInRow, sampInRow )
  118.  
  119. #define MF_submatrix_equM( MDest, destHt, destLen, \
  120.                            firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  121.                            MSrce, srceHt, srceLen ) \
  122.                MFsubmatrix_equM(  MDest[0], destHt, destLen, \
  123.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  124.                              MSrce[0], srceHt, srceLen )
  125.  
  126. /*****   Extracting a single row or a single column or the diagonal  ******
  127.  *       and storing it into a vector                                     */
  128.  
  129. #define MF_Row_extract( Y, MA, ht, len, iRow ) \
  130.                                      MFRow_extract( Y, MA[0], ht, len, iRow )
  131. #define MF_Col_extract( Y, MA, ht, len, iCol ) \
  132.                                      MFCol_extract( Y, MA[0], ht, len, iCol )
  133. #define MF_Dia_extract( Y, MA, len ) MFDia_extract( Y, MA[0], len )
  134.  
  135.  
  136. /*****************    Basic arithmetic operations *********************
  137.                       performed on one single row,
  138.                       or one single column of any matrix,
  139.                       or on the diagonal of a square matrix
  140.  
  141.     Note: In contrast to the analogous VectorLib functions, the operations
  142.     are performed in-place, i.e. the input matrix itself is changed  */
  143.  
  144. #define MF_Row_addC( MA, ht, len, iRow, C ) \
  145.                                      MFRow_addC( MA[0], ht, len, iRow, C )
  146. #define MF_Col_addC( MA, ht, len, iCol, C ) \
  147.                                      MFCol_addC( MA[0], ht, len, iCol, C )
  148. #define MF_Dia_addC( MA, len, C )    MFDia_addC( MA[0], len, C )
  149.  
  150. #define MF_Row_addV( MA, ht, len, iRow, X ) \
  151.                                      MFRow_addV( MA[0], ht, len, iRow, X )
  152. #define MF_Col_addV( MA, ht, len, iCol, X ) \
  153.                                      MFCol_addV( MA[0], ht, len, iCol, X )
  154. #define MF_Dia_addV( MA, len, X )    MFDia_addV( MA[0], len, X )
  155.  
  156. #define MF_Row_subC( MA, ht, len, iRow, C ) \
  157.                                      MFRow_addC( MA[0], ht, len, iRow, (-C) )
  158. #define MF_Col_subC( MA, ht, len, iCol, C ) \
  159.                                      MFCol_addC( MA[0], ht, len, iCol, (-C) )
  160. #define MF_Dia_subC( MA, len, C )    MFDia_addC( MA[0], len, (-C) )
  161.  
  162. #define MF_Row_subV( MA, ht, len, iRow, X ) \
  163.                                      MFRow_subV( MA[0], ht, len, iRow, X )
  164. #define MF_Col_subV( MA, ht, len, iCol, X ) \
  165.                                      MFCol_subV( MA[0], ht, len, iCol, X )
  166. #define MF_Dia_subV( MA, len, X )    MFDia_subV( MA[0], len, X )
  167.  
  168. #define MF_Row_subrC( MA, ht, len, iRow, C ) \
  169.                                      MFRow_subrC( MA[0], ht, len, iRow, C )
  170. #define MF_Col_subrC( MA, ht, len, iCol, C ) \
  171.                                      MFCol_subrC( MA[0], ht, len, iCol, C )
  172. #define MF_Dia_subrC( MA, len, C )   MFDia_subrC( MA[0], len, C )
  173.  
  174. #define MF_Row_subrV( MA, ht, len, iRow, X ) \
  175.                                      MFRow_subrV( MA[0], ht, len, iRow, X )
  176. #define MF_Col_subrV( MA, ht, len, iCol, X ) \
  177.                                      MFCol_subrV( MA[0], ht, len, iCol, X )
  178. #define MF_Dia_subrV( MA, len, X )   MFDia_subrV( MA[0], len, X )
  179.  
  180. #define MF_Row_mulC( MA, ht, len, iRow, C ) \
  181.                                      MFRow_mulC( MA[0], ht, len, iRow, C )
  182. #define MF_Col_mulC( MA, ht, len, iCol, C ) \
  183.                                      MFCol_mulC( MA[0], ht, len, iCol, C )
  184. #define MF_Dia_mulC( MA, len, C )    MFDia_mulC( MA[0], len, C )
  185.  
  186. #define MF_Row_mulV( MA, ht, len, iRow, X ) \
  187.                                      MFRow_mulV( MA[0], ht, len, iRow, X )
  188. #define MF_Col_mulV( MA, ht, len, iCol, X ) \
  189.                                      MFCol_mulV( MA[0], ht, len, iCol, X )
  190. #define MF_Dia_mulV( MA, len, X )    MFDia_mulV( MA[0], len, X )
  191.  
  192. #define MF_Row_divC( MA, ht, len, iRow, C ) \
  193.                                      MFRow_divC( MA[0], ht, len, iRow, C )
  194. #define MF_Col_divC( MA, ht, len, iCol, C ) \
  195.                                      MFCol_divC( MA[0], ht, len, iCol, C )
  196. #define MF_Dia_divC( MA, len, C )    MFDia_divC( MA[0], len, C )
  197.  
  198. #define MF_Row_divV( MA, ht, len, iRow, X ) \
  199.                                       MFRow_divV( MA[0], ht, len, iRow, X )
  200. #define MF_Col_divV( MA, ht, len, iCol, X ) \
  201.                                       MFCol_divV( MA[0], ht, len, iCol, X )
  202. #define MF_Dia_divV( MA, len, X )     MFDia_divV( MA[0], len, X )
  203.  
  204. #define MF_Row_divrC( MA, ht, len, iRow, C ) \
  205.                                       MFRow_divrC( MA[0], ht, len, iRow, C )
  206. #define MF_Col_divrC( MA, ht, len, iCol, C ) \
  207.                                       MFCol_divrC( MA[0], ht, len, iCol, C )
  208. #define MF_Dia_divrC( MA, len, C )    MFDia_divrC( MA[0], len, C )
  209.  
  210. #define MF_Row_divrV( MA, ht, len, iRow, X ) \
  211.                                       MFRow_divrV( MA[0], ht, len, iRow, X )
  212. #define MF_Col_divrV( MA, ht, len, iCol, X ) \
  213.                                       MFCol_divrV( MA[0], ht, len, iCol, X )
  214. #define MF_Dia_divrV( MA, len, X )    MFDia_divrV( MA[0], len, X )
  215.  
  216.  
  217. /******  One-dimensional vector operations **********************
  218.          performed along all rows or all columns simultaneously,
  219.          or along the diagonal of a square matrix                */
  220.  
  221. #define MF_Rows_max( Y, MA, ht, len )     MFRows_max( Y, MA[0], ht, len )
  222. #define MF_Cols_max( Y, MA, ht, len )     MFCols_max( Y, MA[0], ht, len )
  223. #define MF_Dia_max(  MA, len )            MFDia_max(  MA[0], len )
  224. #define MF_Rows_min( Y, MA, ht, len )     MFRows_min( Y, MA[0], ht, len )
  225. #define MF_Cols_min( Y, MA, ht, len )     MFCols_min( Y, MA[0], ht, len )
  226. #define MF_Dia_min(  MA, len )            MFDia_min(  MA[0], len )
  227.  
  228. #define MF_Rows_absmax( Y, MA, ht, len )  MFRows_absmax( Y, MA[0], ht, len )
  229. #define MF_Cols_absmax( Y, MA, ht, len )  MFCols_absmax( Y, MA[0], ht, len )
  230. #define MF_Dia_absmax(  MA, len )         MFDia_absmax(  MA[0], len )
  231. #define MF_Rows_absmin( Y, MA, ht, len )  MFRows_absmin( Y, MA[0], ht, len )
  232. #define MF_Cols_absmin( Y, MA, ht, len )  MFCols_absmin( Y, MA[0], ht, len )
  233. #define MF_Dia_absmin(  MA, len )         MFDia_absmin(  MA[0], len )
  234.  
  235. #define MF_Rows_sum( Y, MA, ht, len )     MFRows_sum( Y, MA[0], ht, len )
  236. #define MF_Cols_sum( Y, MA, ht, len )     MFCols_sum( Y, MA[0], ht, len )
  237. #define MF_Dia_sum(  MA, len )            MFDia_sum(  MA[0], len )
  238. #define MF_Rows_prod( Y, MA, ht, len )    MFRows_prod( Y, MA[0], ht, len )
  239. #define MF_Cols_prod( Y, MA, ht, len )    MFCols_prod( Y, MA[0], ht, len )
  240. #define MF_Dia_prod(  MA, len )           MFDia_prod( MA[0], len )
  241.  
  242. #define MF_Rows_runsum( MA, ht, len )     MFRows_runsum( MA[0], ht, len )
  243. #define MF_Cols_runsum( MA, ht, len )     MFCols_runsum( MA[0], ht, len )
  244. #define MF_Rows_runprod( MA, ht, len )    MFRows_runprod( MA[0], ht, len )
  245. #define MF_Cols_runprod( MA, ht, len )    MFCols_runprod( MA[0], ht, len )
  246.  
  247. #define MF_Rows_rotate( MA, ht, len, pos) MFRows_rotate( MA[0], ht, len, pos )
  248. #define MF_Cols_rotate( MA, ht, len, pos) MFCols_rotate( MA[0], ht, len, pos )
  249. #define MF_Rows_reflect( MA, ht, len)     MFRows_reflect( MA[0], ht, len )
  250. #define MF_Cols_reflect( MA, ht, len)     MFCols_reflect( MA[0], ht, len )
  251.  
  252. /********  Operations involving two rows or two colums of one matrix  *****/
  253.  
  254. #define MF_Rows_exchange( MA, ht, len, row1, row2 ) \
  255.                              MFRows_exchange( MA[0], ht, len, row1, row2 )
  256. #define MF_Cols_exchange( MA, ht, len, col1, col2 ) \
  257.                              MFCols_exchange( MA[0], ht, len, col1, col2 )
  258.  
  259. #define MF_Rows_add( MA, ht, len, destRow, srceRow ) \
  260.                              MFRows_add( MA[0], ht, len, destRow, srceRow )
  261. #define MF_Cols_add( MA, ht, len, destCol, srceCol ) \
  262.                              MFCols_add( MA[0], ht, len, destCol, srceCol )
  263.                          /* dest[i] += source[i]  */
  264.  
  265. #define MF_Rows_sub( MA, ht, len, destRow, srceRow ) \
  266.                              MFRows_sub( MA[0], ht, len, destRow, srceRow )
  267. #define MF_Cols_sub( MA, ht, len, destCol, srceCol ) \
  268.                              MFCols_sub( MA[0], ht, len, destCol, srceCol )
  269.                          /* dest[i] -= source[i]  */
  270.  
  271. #define MF_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  272.                           MFRows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  273. #define MF_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  274.                           MFCols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  275.                          /* dest[i] += C * source[i]  */
  276.  
  277. #define MF_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  278.             MFRows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  279. #define MF_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  280.             MFCols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  281.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  282.  
  283.  
  284. /*************************  Transposing a matrix **********************/
  285.  
  286. #define MF_transpose( MTr, MA, htTr, lenTr ) \
  287.              MFtranspose( MTr[0], MA[0], htTr, lenTr )
  288.        /*  dimensions htTr, lenTr are those of the transposed matrix,
  289.            not of the original!                */
  290.  
  291.  
  292. /************************ Matrix Multiplication *************************/
  293.  
  294. #define MF_mulV( Y, MA, X, htA, lenA ) \
  295.                     MFmulV( Y, MA[0], X, htA, lenA )
  296.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  297.                               both X and Y are column-vectors    */
  298. #define VF_mulM( Y, X, MA, sizX, lenA ) \
  299.                     VFmulM( Y, X, MA[0], sizX, lenA )
  300.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  301.                              both X and Y are row-vectors.
  302.                              Mind the prefix: VF_ (not MF_)    */
  303. #define MF_mulM( MC, MA, MB, htA, lenA, lenB ) \
  304.                     MFmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  305.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  306.  
  307.  
  308. /*************************  Linear Algebra    *****************************/
  309.  
  310.    /*  The standard treatment of linear systems is based
  311.        on LUD (matrix decomposition into Upper-triangular
  312.        and Lower-triangular components). The result of the
  313.        decomposition step is used for further operations.  */
  314.  
  315. #define MF_LUdecompose( MLU, Ind, MA, len ) \
  316.                     MFLUdecompose( MLU[0], Ind, MA[0], len )
  317.             /* returns "permut" = +-1 which is needed for MF_LUdet.
  318.                for singularities not cured by editing, permut is 0  */
  319. int     __vf MF_LUDresult( void );
  320.     /* returns 0, if MF_LUdecompose was successful;
  321.        returns 1, if MA was (nearly) singular in MF_LUdecompose.   */
  322. void    __vf MF_LUDsetEdit( float Thresh );
  323. float   __vf MF_LUDgetEdit( void );
  324.      /*  Editing threshold valid for MF_LUdecompose;
  325.          may be used to cure singularities           */
  326.  
  327. #define MF_LUsolve( X, MLU, B, Ind, len ) \
  328.                     MFLUsolve( X, MLU[0], B, Ind, len )
  329. #define MF_LUinv( MInv, MLU, Ind, len ) \
  330.                     MFLUinv( MInv[0], MLU[0], Ind, len )
  331. #define MF_LUdet( MLU, len, permut ) MFLUdet( MLU[0], len, permut )
  332. #define MF_LUimprove( X, B, MA, MLU, Ind, len ) \
  333.                       MFLUimprove( X, B, MA[0], MLU[0], Ind, len )
  334.  
  335.     /****  Special treatment of over- or under-determined
  336.            linear systems, i.e. of matrices with len != ht
  337.            and of singular matrices:
  338.            SVD (Singular Value Decomposition)       ****/
  339.  
  340. #define MF_SVdecompose( MU, MV, W, MA, htA, lenA ) \
  341.                     MFSVdecompose( MU[0], MV[0], W, MA[0], htA, lenA )
  342.             /*  sizB = htA,  sizX = sizW = htV = lenV = lenA  */
  343. #define MF_SVsolve( X, MU, MV, W, B, htU, lenU ) \
  344.                     MFSVsolve( X, MU[0], MV[0], W, B, htU, lenU )
  345.             /*  lenU = lenA,  htU = max( lenA, htA ) as fed into
  346.                 MD_SVdecompose   */
  347. #define MF_SVimprove( X, B, MA, MU, MV, W, htA, lenA ) \
  348.                     MFSVimprove( X, B, MA[0], MU[0], MV[0], W, htA, lenA )
  349. void    __vf MF_SVDsetEdit( float Thresh );
  350. float   __vf MF_SVDgetEdit( void );
  351.     /* Override of the standard values for editing threshholds
  352.        in MF_SVsolve. Calling MF_setEdit with Thresh=0.0 means
  353.        that you do the necessary editing of W yourself
  354.        before calling MD_SVsolve                           */
  355.  
  356.  /*****  "Easy-to-use" versions of the matrix functions
  357.           using LUD or SVD.
  358.           They allocate their own working space and rely
  359.           on your setting of the editing threshold. In
  360.           case of memory stress, you should better use the
  361.           two-step methods declared above.            ***/
  362. #define MF_solve( X, MA, B, len ) \
  363.                     MFsolve( X, MA[0], B, len )
  364. #define MF_inv( MInv, MA, len ) \
  365.                     MFinv( MInv[0], MA[0], len )
  366. #define MF_det(  MA, len ) \
  367.                     MFdet( MA[0], len )
  368. #define MF_solveBySVD( X, MA, B, ht, len ) \
  369.                     MFsolveBySVD( X, MA[0], B, ht, len )
  370.          /*  sizX = len,  sizB = ht  */
  371. #define MF_safeSolve( X, MA, B, len ) \
  372.                     MFsafeSolve( X, MA[0], B, len )
  373.         /* MF_safeSolve tries first LUD. If that fails, SVD is done.
  374.            X[i] will be 0.0 instead of INF for those i corresponding
  375.            to singularities. If even SVD fails, all X[i] are set to 0.0.
  376.            return value 0: success via LUD; 1: success via SVD; -1: failure */
  377.  
  378.       /*********  Eigenvalues and Eigenvectors  ********/
  379.       /*** only the most frequent case of symmetric real matrices
  380.            is covered here! *********/
  381.  
  382. #define MFsym_eigenvalues( EigV, EigM, MA, len, CalcEigenVec ) \
  383.                     MFs_eigenvalues( EigV, EigM[0], MA[0], len, CalcEigenVec )
  384.                         /*  Eigenvalues are returned in EigV.
  385.                             CalcEigenVec = 0 means that only eigenvalues
  386.                             are needed; CalcEigenVec != 0 means that
  387.                             also eigenvectors are calculated. If so,
  388.                             eigenvectors are returned as the columns of EigM.
  389.                             Even if eigenvectors are not desired, EigM is
  390.                             needed by the function as working-space. Then, on
  391.                             output, it will contain just rubbish.
  392.                             MA may be overwritten by EigM. */
  393.  
  394. /***************** Two-Dimensional Fourier-Transform Methods ************/
  395.  
  396. void      __vf   VF_setRspEdit( fComplex Trunc );
  397. fComplex  __vf   VF_getRspEdit( void );
  398.            /* these are the same functions as used
  399.               in the one-dimensional case */
  400.  
  401. #define MFl_FFT( MY, MX, ht, len, dir )     MFlFFT( MY[0], MX[0], ht, len, dir )
  402. #define MFs_FFT( MY, MX, ht, len, dir )     MFsFFT( MY[0], MX[0], ht, len, dir )
  403. #define MFl_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  404.                   MFlconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  405. #define MFl_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  406.                   MFldeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  407. #define MFl_filter( MY, MX, MFlt, ht, len ) MFlfilter( MY[0], MX[0], MFlt[0], ht, len )
  408. #define MFl_autocorr( MACorr, MX, ht, len ) MFlautocorr( MACorr[0], MX[0], ht, len )
  409. #define MFl_xcorr( MXCorr, MX, MY, ht, len) MFlxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  410. #define MFl_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  411.               MFlspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  412.                   /* htSpec, lenSpec must be 2**n,
  413.                      MSpec must be a (htSpec+1)*(lenSpec+1) matrix!!
  414.                      htX >= n*htSpec,  lenX >= n*lenSpec,
  415.                      htWin = 2*htSpec, lenWin = 2*lenSpec */
  416.  
  417. #define MFs_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  418.                   MFsconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  419. #define MFs_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  420.                   MFsdeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  421. #define MFs_filter( MY, MX, MFlt, ht, len ) MFsfilter( MY[0], MX[0], MFlt[0], ht, len )
  422. #define MFs_autocorr( MACorr, MX, ht, len ) MFsautocorr( MACorr[0], MX[0], ht, len )
  423. #define MFs_xcorr( MXCorr, MX, MY, ht, len) MFsxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  424. #define MFs_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  425.               MFsspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  426.                 /*   htSpec, lenSpec must be 2**n,
  427.                      MSpec has [htSpec+1][lenSpec+1] elements (!)
  428.                      htX >= n*htSpec,  lenX >= n*lenSpec,
  429.                      htWin = 2*htSpec, lenWin = 2*lenSpec     */
  430.  
  431. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  432.    #define MF_FFT         MFl_FFT
  433.    #define MF_convolve    MFl_convolve
  434.    #define MF_deconvolve  MFl_deconvolve
  435.    #define MF_filter      MFl_filter
  436.    #define MF_autocorr    MFl_autocorr
  437.    #define MF_xcorr       MFl_xcorr
  438.    #define MF_spectrum    MFl_spectrum
  439. #else
  440.    #define MF_FFT         MFs_FFT
  441.    #define MF_convolve    MFs_convolve
  442.    #define MF_deconvolve  MFs_deconvolve
  443.    #define MF_filter      MFs_filter
  444.    #define MF_autocorr    MFs_autocorr
  445.    #define MF_xcorr       MFs_xcorr
  446.    #define MF_spectrum    MFs_spectrum
  447. #endif
  448.  
  449.  
  450. /************************** Data Fitting *********************************
  451.  
  452.   Notice that some of these functions have the prefix VF_, others MF_.
  453.   This depends on the form in which the data to be fitted are recorded:
  454.   vectors are fitted by the VF_ functions, matrices by the MF_ functions.
  455.   All of these functions employ matrix methods internally. The weighted
  456.   versions return covariances in a matrix "Covar". So they are all
  457.   contained in MatrixLib and declared here.
  458. */
  459.  
  460. void __vf VF_polyfit( fVector A, unsigned deg, fVector X, fVector Y, ui sizex );
  461. #define   VF_polyfitwW( A, Covar, deg, X, Y, InvVar, sizex ) \
  462.           VFpolyfitwW( A, Covar[0], deg, X, Y, InvVar, sizex )
  463.        /* the size of A is deg+1 and Covar has [deg+1][deg+1] elements! */
  464.  
  465. void __vf VF_linfit( fVector A, iVector AStatus, unsigned npars,
  466.                      fVector X, fVector Y, ui sizex,
  467.                      void (*funcs)(fVector BasFuncs, float x, unsigned nfuncs) );
  468. #define   VF_linfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, funcs ) \
  469.           VFlinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, funcs )
  470. #define   MF_linfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, funcs ) \
  471.           MFlinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, funcs )
  472. #define   MF_linfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, funcs ) \
  473.           MFlinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, funcs )
  474.  
  475. void  __vf VF_setLinfitNeglect( float Thresh );
  476.                    /* neglect A[i]=0, if significance smaller than Thresh */
  477. float __vf VF_getLinfitNeglect( void );
  478.  
  479. float __vf VF_nonlinfit( fVector A, iVector AStatus, unsigned npars,
  480.                          fVector X, fVector Y, ui sizex,
  481.                          void (*modelfunc)(fVector YModel, fVector XModel, ui size),
  482.                          void (*derivatives)(fVector dYdAi,fVector X, ui size, unsigned iPar) );
  483.             /* returns figure-of-merit of best A. If you don't know the partial
  484.                derivatives with respect to A, call with derivatives=NULL */
  485. #define   VF_nonlinfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv ) \
  486.           VFnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv )
  487. #define   MF_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, modelfunc, deriv ) \
  488.           MFnonlinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, modelfunc, deriv )
  489. #define   MF_nonlinfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, modelfunc, deriv ) \
  490.           MFnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, modelfunc, deriv )
  491.  
  492.         /* If you know some partial derivatives, you may call these functions
  493.            for those parameters for which you do not know them:           */
  494. void     __vf VF_nonlinfit_autoDeriv( fVector dYdAi, fVector X, ui size, unsigned ipar );
  495. void     __vf VF_nonlinfitwW_autoDeriv( fVector dYdAi, fVector X, ui size, unsigned ipar );
  496. void     __vf MF_nonlinfit_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar );
  497. void     __vf MF_nonlinfitwW_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar );
  498.        /* The following functions allow to monitor the progress of
  499.           a nonlinear fitting procedure or to manually stop it:     */
  500. float    __vf VF_nonlinfit_getChi2( void );
  501. float    __vf VF_nonlinfitwW_getChi2( void );
  502. float    __vf MF_nonlinfit_getChi2( void );
  503. float    __vf MF_nonlinfitwW_getChi2( void );
  504. void     __vf VF_nonlinfit_getBestA( fVector ABest );
  505. void     __vf VF_nonlinfitwW_getBestA( fVector ABest );
  506. void     __vf MF_nonlinfit_getBestA( fVector ABest );
  507. void     __vf MF_nonlinfitwW_getBestA( fVector ABest );
  508. unsigned __vf VF_nonlinfit_getTestRun( void );
  509. unsigned __vf VF_nonlinfitwW_getTestRun( void );
  510. unsigned __vf MF_nonlinfit_getTestRun( void );
  511. unsigned __vf MF_nonlinfitwW_getTestRun( void );
  512. unsigned __vf VF_nonlinfit_getTestPar( void );
  513. unsigned __vf VF_nonlinfitwW_getTestPar( void );
  514. unsigned __vf MF_nonlinfit_getTestPar( void );
  515. unsigned __vf MF_nonlinfitwW_getTestPar( void );
  516. int      __vf VF_nonlinfit_getTestDir( void );
  517. int      __vf VF_nonlinfitwW_getTestDir( void );
  518. int      __vf MF_nonlinfit_getTestDir( void );
  519. int      __vf MF_nonlinfitwW_getTestDir( void );
  520. void     __vf VF_nonlinfit_stop( void );
  521. void     __vf VF_nonlinfitwW_stop( void );
  522. void     __vf MF_nonlinfit_stop( void );
  523. void     __vf MF_nonlinfitwW_stop( void );
  524.  
  525. #ifdef __BORLANDC__
  526.     #pragma option -a-  /* avoid insertion of dummy bytes */
  527. #else   /* MS Visual C++ */
  528.     #pragma pack(push,1)
  529. #endif    /*  Borland or Microsoft */
  530. typedef struct VF_NONLINFITOPTIONS
  531. {
  532.       int        FigureOfMerit;  /*  0:least squares, 1:robust */
  533.              /* Convergence conditions: if the changes achieved
  534.                 in successive iterations are lower than any of the
  535.                 following values, this signals convergence. Set
  536.                 criteria to 0.0, if not applicable              */
  537.       float      AbsTolChi,  /* absolute change of chi */
  538.                  FracTolChi, /* fractional change of chi */
  539.                  AbsTolPar,  /* absolute change of all parameters */
  540.                  FracTolPar; /* fractional change of all parameters */
  541.       unsigned   HowOftenFulfill; /* how often fulfill the above conditions? */
  542.       unsigned   LevelOfMethod;  /* 1: Levenberg-Marquardt method,
  543.                                     2: Downhill Simplex (Nelder and Mead) method,
  544.                                     3: both methods alternating;
  545.                                        add 4 to this in order to try
  546.                                        breaking out of local minima;
  547.                                     0: no fit, calculate only chi2 (and Covar) */
  548.       unsigned   LevMarIterations; /* max.number of successful iterations of LevMar */
  549.       unsigned   LevMarStarts; /* number of starts per LevMar run */
  550.       float      LambdaStart,
  551.                  LambdaMin, LambdaMax,
  552.                  LambdaDiv, LambdaMul;    /* LevMar parameter lambda */
  553.       unsigned   DownhillIterations; /* max.number of successful iterations in Downhill */
  554.       float      DownhillReflection,  /* re-shaping of the simplex */
  555.                  DownhillContraction,
  556.                  DownhillExpansion;
  557.       unsigned   TotalStarts;  /* max. number of LevMar/Downhill pairs */
  558.       fVector    UpperLimits;  /* impose upper limits on parameters */
  559.       fVector    LowerLimits;  /* impose lower limits on parameters */
  560.       void       (*Restrictions)(void);  /* user-defined editing of parameters */
  561. }  VF_NONLINFITOPTIONS;
  562.  
  563. void __vf VF_setNonlinfitOptions( VF_NONLINFITOPTIONS _VFAR *Options );
  564. void __vf VF_getNonlinfitOptions( VF_NONLINFITOPTIONS _VFAR *Options );
  565.  
  566. typedef struct VF_EXPERIMENT
  567. {
  568.     fVector X, Y, InvVar;
  569.     ui      size;
  570.     float   WeightOfExperiment;
  571.      /* InvVar and WeightOfExperiment are needed only for the
  572.         weighted variants of the multifit functions */
  573. } VF_EXPERIMENT;
  574.  
  575. typedef struct MF_EXPERIMENT
  576. {
  577.     fVector   X, Y;
  578.     fMatrix   MZ, MInvVar;  /* here no compatibility with static matrices! */
  579.     unsigned  htZ, lenZ;
  580.     float     WeightOfExperiment;
  581.      /* MInvVar and WeightOfExperiment are needed only for the
  582.         weighted variants of the multifit functions */
  583. } MF_EXPERIMENT;
  584. #ifdef __BORLANDC__
  585.     #pragma option -a.   /* restore default data packing  */
  586. #else   /* MS Visual C++ */
  587.     #pragma pack(pop)
  588. #endif
  589.  
  590.  
  591. void __vf VF_multiLinfit( fVector A, iVector AStatus, unsigned ma,
  592.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  593.                 void (*funcs)(fVector BasFuncs, float x,
  594.                               unsigned nfuncs, unsigned iexperiment) );
  595. #define   VF_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  596.           VFmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  597. void __vf MF_multiLinfit( fVector A, iVector AStatus, unsigned ma,
  598.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  599.                 void (*funcs)(fVector BasFuncs, float x, float y,
  600.                               unsigned nfuncs, unsigned iexperiment) );
  601. #define   MF_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  602.           MFmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  603. float __vf VF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
  604.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  605.                 void (*modelfunc)(fVector YModel, fVector XModel,
  606.                                   ui size, unsigned iexperiment),
  607.                 void (*derivatives)(fVector dYdAi,fVector X, ui size,
  608.                                   unsigned ipar, unsigned iexperiment) );
  609.             /* returns figure-of-merit of best A. If you don't know the
  610.                partial derivatives, set derivatives=NULL */
  611. #define   VF_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  612.           VFmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  613. float __vf MF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
  614.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  615.                 void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ,
  616.                                   fVector X, fVector Y, unsigned iexperiment),
  617.                 void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  618.                                     fVector X, fVector Y, unsigned ipar,
  619.                                     unsigned iexperiment) );
  620. #define   MF_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  621.           MFmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  622.  
  623. void  __vf VF_multiNonlinfit_autoDeriv( fVector dYdAi, fVector X, ui size,
  624.                                        unsigned iexperiment, unsigned ipar );
  625. void  __vf VF_multiNonlinfitwW_autoDeriv( fVector dYdAi, fVector X, ui size,
  626.                                        unsigned iexperiment, unsigned ipar );
  627. void  __vf MF_multiNonlinfit_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  628.                                     fVector X, fVector Y,
  629.                                     unsigned ipar, unsigned iexperiment );
  630. void  __vf MF_multiNonlinfitwW_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  631.                                     fVector X, fVector Y,
  632.                                     unsigned ipar, unsigned iexperiment );
  633. float    __vf VF_multiNonlinfit_getChi2( void );
  634. float    __vf VF_multiNonlinfitwW_getChi2( void );
  635. float    __vf MF_multiNonlinfit_getChi2( void );
  636. float    __vf MF_multiNonlinfitwW_getChi2( void );
  637. void     __vf VF_multiNonlinfit_getBestA( fVector ABest );
  638. void     __vf VF_multiNonlinfitwW_getBestA( fVector ABest );
  639. void     __vf MF_multiNonlinfit_getBestA( fVector ABest );
  640. void     __vf MF_multiNonlinfitwW_getBestA( fVector ABest );
  641. unsigned __vf VF_multiNonlinfit_getTestRun( void );
  642. unsigned __vf VF_multiNonlinfitwW_getTestRun( void );
  643. unsigned __vf MF_multiNonlinfit_getTestRun( void );
  644. unsigned __vf MF_multiNonlinfitwW_getTestRun( void );
  645. unsigned __vf VF_multiNonlinfit_getTestPar( void );
  646. unsigned __vf VF_multiNonlinfitwW_getTestPar( void );
  647. unsigned __vf MF_multiNonlinfit_getTestPar( void );
  648. unsigned __vf MF_multiNonlinfitwW_getTestPar( void );
  649. int      __vf VF_multiNonlinfit_getTestDir( void );
  650. int      __vf VF_multiNonlinfitwW_getTestDir( void );
  651. int      __vf MF_multiNonlinfit_getTestDir( void );
  652. int      __vf MF_multiNonlinfitwW_getTestDir( void );
  653. void     __vf VF_multiNonlinfit_stop( void );
  654. void     __vf VF_multiNonlinfitwW_stop( void );
  655. void     __vf MF_multiNonlinfit_stop( void );
  656. void     __vf MF_multiNonlinfitwW_stop( void );
  657.  
  658. /**************************  Input and Output  **************************/
  659.  
  660. #define MF_fprint( stream, MA, ht, len, linewidth ) \
  661.                     MFfprint( stream, MA[0], ht, len, linewidth )
  662. #define MF_print( MA, ht, len )  MFfprint( stdout, MA[0], ht, len, 80 )
  663.           /*  MF_print is usable only for DOS and EasyWin!  */
  664. #ifndef _Windows
  665.     #define MF_cprint( MA, ht, len ) MFcprint( MA[0], ht, len )
  666. #endif
  667.  
  668. #define MF_write( str, MA, ht, len )   MFwrite( str, MA[0], ht, len )
  669. #define MF_read( MA, ht, len, str )    MFread( MA[0], ht, len, str )
  670. #define MF_setWriteFormat              VF_setWriteFormat
  671. #define MF_setWriteSeparate            VF_setNWriteSeparate
  672.                                    /* write and read in ascii format */
  673. #define MF_store( str, MA, ht, len ) \
  674.                            VF_store( str, MA[0], ((ui) (len))*(ht) );
  675. #define MF_recall( MA, ht, len, str) \
  676.                            VF_recall( MA[0], ((ui) (len))*(ht), str);
  677.                                   /* store and recall in binary format */
  678.  
  679.  
  680. /*************************************************************************
  681.  * Here are now the actual declarations of the functions used internally.*
  682.  * These declarations may change in future versions of MatrixLib!        *
  683.  * You should not care too much about them, except in the case you need  *
  684.  * the actual address of a run-time function (see above). Under all      *
  685.  * "normal" circumstances, use only the names defined above in the       *
  686.  * macro section!                                                        *
  687.  *************************************************************************/
  688.  
  689. float _VFAR * MFPelement( fPMatrix X, unsigned ht, unsigned len,
  690.                           unsigned m, unsigned n );
  691.                   /* pointer is normalized in memory model HUGE */
  692.  
  693. void   __vf  MFequ1( fPMatrix MA, unsigned len );  /* identity matrix */
  694. void   __vf  MFouterprod( fPMatrix MA, fVector X,  fVector Y,
  695.                           unsigned ht, unsigned len );
  696.  
  697. void   __vf  MFRow_equC( fPMatrix MA, unsigned ht, unsigned len,
  698.                          unsigned iRow, float C );
  699. void   __vf  MFCol_equC( fPMatrix MA, unsigned ht, unsigned len,
  700.                          unsigned iCol, float C );
  701. void   __vf  MFDia_equC( fPMatrix MA, unsigned len, float C );
  702.  
  703. void   __vf  MFRow_equV( fPMatrix MA, unsigned ht, unsigned len,
  704.                          unsigned iRow, fVector X );
  705. void   __vf  MFCol_equV( fPMatrix MA, unsigned ht, unsigned len,
  706.                          unsigned iCol, fVector X );
  707. void   __vf  MFDia_equV( fPMatrix MA, unsigned len, fVector X );
  708.  
  709. void   __vf  MFUequL( fPMatrix MA, unsigned len );
  710. void   __vf  MFLequU( fPMatrix MA, unsigned len );
  711.  
  712. void   __vf  MFHanning( fPMatrix MA, unsigned ht, unsigned len );
  713. void   __vf  MFParzen(  fPMatrix MA, unsigned ht, unsigned len );
  714. void   __vf  MFWelch(   fPMatrix MA, unsigned ht, unsigned len );
  715.  
  716. /********  Extracting a submatrix and copying a submatrix back  *********/
  717.  
  718. void  __vf  MFsubmatrix( fPMatrix MSub,
  719.                           unsigned subHt,  unsigned subLen,
  720.                           fPMatrix MSrce,
  721.                           unsigned srceHt,  unsigned srceLen,
  722.                           unsigned firstRowInCol,  unsigned sampInCol,
  723.                           unsigned firstColInRow,  unsigned sampInRow );
  724.  
  725. void  __vf  MFsubmatrix_equM( fPMatrix MDest,
  726.                                unsigned destHt,     unsigned destLen,
  727.                                unsigned firstRowInCol,  unsigned sampInCol,
  728.                                unsigned firstColInRow,  unsigned sampInRow,
  729.                                fPMatrix MSrce,
  730.                                unsigned srceHt,     unsigned srceLen );
  731.  
  732.  
  733. /*****   Extracting a single row or a single column or the diagonal  *****
  734.  *       and storing it into a vector                                    */
  735.  
  736. void __vf MFRow_extract( fVector Y, fPMatrix MA, unsigned ht, unsigned len,
  737.                            unsigned iRow );
  738. void __vf MFCol_extract( fVector Y, fPMatrix MA, unsigned ht, unsigned len,
  739.                            unsigned iCol );
  740. void __vf MFDia_extract( fVector Y, fPMatrix MA, unsigned len );
  741.  
  742.  
  743. /*****************    Basic arithmetic operations ***********************
  744.      performed on one single row,  or one single column of any matrix,
  745.      or on the diagonal of a square matrix                              */
  746.  
  747. void   __vf  MFRow_addC( fPMatrix MA, unsigned ht, unsigned len,
  748.                          unsigned iRow, float C );
  749. void   __vf  MFCol_addC( fPMatrix MA, unsigned ht, unsigned len,
  750.                          unsigned iCol, float C );
  751. void   __vf  MFDia_addC( fPMatrix MA, unsigned len, float C );
  752.  
  753. void   __vf  MFRow_subC( fPMatrix MA, unsigned ht, unsigned len,
  754.                          unsigned iRow, float C );
  755. void   __vf  MFCol_subC( fPMatrix MA, unsigned ht, unsigned len,
  756.                          unsigned iCol, float C );
  757. void   __vf  MFDia_subC( fPMatrix MA, unsigned len, float C );
  758.  
  759. void   __vf  MFRow_addV( fPMatrix MA, unsigned ht, unsigned len,
  760.                          unsigned iRow, fVector X );
  761. void   __vf  MFCol_addV( fPMatrix MA, unsigned ht, unsigned len,
  762.                          unsigned iCol, fVector X );
  763. void   __vf  MFDia_addV( fPMatrix MA, unsigned len, fVector X );
  764.  
  765. void   __vf  MFRow_subV( fPMatrix MA, unsigned ht, unsigned len,
  766.                          unsigned iRow, fVector X );
  767. void   __vf  MFCol_subV( fPMatrix MA, unsigned ht, unsigned len,
  768.                          unsigned iCol, fVector X );
  769. void   __vf  MFDia_subV( fPMatrix MA, unsigned len, fVector X );
  770.  
  771. void   __vf  MFRow_subrC( fPMatrix MA, unsigned ht, unsigned len,
  772.                          unsigned iRow, float C );
  773. void   __vf  MFCol_subrC( fPMatrix MA, unsigned ht, unsigned len,
  774.                          unsigned iCol, float C );
  775. void   __vf  MFDia_subrC( fPMatrix MA, unsigned len, float C );
  776.  
  777. void   __vf  MFRow_subrV( fPMatrix MA, unsigned ht, unsigned len,
  778.                          unsigned iRow, fVector X );
  779. void   __vf  MFCol_subrV( fPMatrix MA, unsigned ht, unsigned len,
  780.                          unsigned iCol, fVector X );
  781. void   __vf  MFDia_subrV( fPMatrix MA, unsigned len, fVector X );
  782.  
  783. void   __vf  MFRow_mulC( fPMatrix MA, unsigned ht, unsigned len,
  784.                          unsigned iRow, float C );
  785. void   __vf  MFCol_mulC( fPMatrix MA, unsigned ht, unsigned len,
  786.                          unsigned iCol, float C );
  787. void   __vf  MFDia_mulC( fPMatrix MA, unsigned len, float C );
  788.  
  789. void   __vf  MFRow_mulV( fPMatrix MA, unsigned ht, unsigned len,
  790.                          unsigned iRow, fVector X );
  791. void   __vf  MFCol_mulV( fPMatrix MA, unsigned ht, unsigned len,
  792.                          unsigned iCol, fVector X );
  793. void   __vf  MFDia_mulV( fPMatrix MA, unsigned len, fVector X );
  794.  
  795. void   __vf  MFRow_divC( fPMatrix MA, unsigned ht, unsigned len,
  796.                          unsigned iRow, float C );
  797. void   __vf  MFCol_divC( fPMatrix MA, unsigned ht, unsigned len,
  798.                          unsigned iCol, float C );
  799. void   __vf  MFDia_divC( fPMatrix MA, unsigned len, float C );
  800.  
  801. void   __vf  MFRow_divV( fPMatrix MA, unsigned ht, unsigned len,
  802.                          unsigned iRow, fVector X );
  803. void   __vf  MFCol_divV( fPMatrix MA, unsigned ht, unsigned len,
  804.                          unsigned iCol, fVector X );
  805. void   __vf  MFDia_divV( fPMatrix MA, unsigned len, fVector X );
  806.  
  807. void   __vf  MFRow_divrC( fPMatrix MA, unsigned ht, unsigned len,
  808.                          unsigned iRow, float C );
  809. void   __vf  MFCol_divrC( fPMatrix MA, unsigned ht, unsigned len,
  810.                          unsigned iCol, float C );
  811. void   __vf  MFDia_divrC( fPMatrix MA, unsigned len, float C );
  812.  
  813. void   __vf  MFRow_divrV( fPMatrix MA, unsigned ht, unsigned len,
  814.                          unsigned iRow, fVector X );
  815. void   __vf  MFCol_divrV( fPMatrix MA, unsigned ht, unsigned len,
  816.                          unsigned iCol, fVector X );
  817. void   __vf  MFDia_divrV( fPMatrix MA, unsigned len, fVector X );
  818.  
  819.  
  820. /******  One-dimensional vector operations **********************
  821.          performed along all rows or all columns simultaneously,
  822.          or along the diagonal of a square matrix                */
  823.  
  824. void  __vf  MFRows_max( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  825. void  __vf  MFCols_max( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  826. float __vf  MFDia_max(  fPMatrix MA, unsigned len );
  827. void  __vf  MFRows_min( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  828. void  __vf  MFCols_min( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  829. float __vf  MFDia_min(  fPMatrix MA, unsigned len );
  830.  
  831. void  __vf  MFRows_absmax( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  832. void  __vf  MFCols_absmax( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  833. float __vf  MFDia_absmax(  fPMatrix MA, unsigned len );
  834. void  __vf  MFRows_absmin( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  835. void  __vf  MFCols_absmin( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  836. float __vf  MFDia_absmin(  fPMatrix MA, unsigned len );
  837.  
  838. void  __vf  MFRows_sum( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  839. void  __vf  MFCols_sum( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  840. float __vf  MFDia_sum(  fPMatrix MA, unsigned len );
  841. void  __vf  MFRows_prod(fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  842. void  __vf  MFCols_prod(fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  843. float __vf  MFDia_prod( fPMatrix MA, unsigned len );
  844.  
  845. void  __vf  MFRows_runsum( fPMatrix MA, unsigned ht, unsigned len );
  846. void  __vf  MFCols_runsum( fPMatrix MA, unsigned ht, unsigned len );
  847. void  __vf  MFRows_runprod( fPMatrix MA, unsigned ht, unsigned len );
  848. void  __vf  MFCols_runprod( fPMatrix MA, unsigned ht, unsigned len );
  849.  
  850. void  __vf  MFRows_rotate( fPMatrix MA, unsigned ht, unsigned len, int pos );
  851. void  __vf  MFCols_rotate( fPMatrix MA, unsigned ht, unsigned len, int pos );
  852. void  __vf  MFRows_reflect( fPMatrix MA, unsigned ht, unsigned len );
  853. void  __vf  MFCols_reflect( fPMatrix MA, unsigned ht, unsigned len );
  854.  
  855. /********  Operations involving two rows or two colums of one matrix  *****/
  856.  
  857. void   __vf  MFRows_exchange( fPMatrix MA, unsigned ht, unsigned len,
  858.                               unsigned i1, unsigned i2 );
  859. void   __vf  MFCols_exchange( fPMatrix MA, unsigned ht, unsigned len,
  860.                               unsigned i1, unsigned i2 );
  861.  
  862. void   __vf  MFRows_add( fPMatrix MA, unsigned ht, unsigned len,
  863.                           unsigned destRow, unsigned sourceRow );
  864. void   __vf  MFCols_add( fPMatrix MA, unsigned ht, unsigned len,
  865.                           unsigned destCol, unsigned sourceCol );
  866.  
  867. void   __vf  MFRows_sub( fPMatrix MA, unsigned ht, unsigned len,
  868.                           unsigned destRow, unsigned sourceRow );
  869. void   __vf  MFCols_sub( fPMatrix MA, unsigned ht, unsigned len,
  870.                           unsigned destCol, unsigned sourceCol );
  871.  
  872. void   __vf  MFRows_Cadd( fPMatrix MA, unsigned ht, unsigned len,
  873.                            unsigned destRow, unsigned sourceRow, float C );
  874. void   __vf  MFCols_Cadd( fPMatrix MA, unsigned ht, unsigned len,
  875.                            unsigned destCol, unsigned sourceCol, float C );
  876.  
  877. void   __vf  MFRows_lincomb( fPMatrix MA, unsigned ht, unsigned len,
  878.                               unsigned destRow,  float  destC,
  879.                               unsigned srceRow,  float  srceC );
  880. void   __vf  MFCols_lincomb( fPMatrix MA, unsigned ht, unsigned len,
  881.                               unsigned destCol,  float  destC,
  882.                               unsigned srceCol,  float  srceC );
  883.  
  884.  
  885. /*************************  Transposing a matrix **********************/
  886.  
  887. void  __vf  MFtranspose( fPMatrix MTr, fPMatrix MA,
  888.                           unsigned htTr, unsigned lenTr );
  889.  
  890.  
  891. /************************ Matrix Multiplication *************************/
  892.  
  893. void  __vf  MFmulV( fVector Y, fPMatrix MA, fVector X,
  894.                     unsigned htA, unsigned lenA );
  895. void  __vf  VFmulM( fVector Y, fVector X, fPMatrix MA,
  896.                     unsigned sizX, unsigned lenA );
  897. void  __vf  MFmulM( fPMatrix MC, fPMatrix MA, fPMatrix MB,
  898.                     unsigned htA, unsigned lenA, unsigned lenB );
  899.  
  900.  
  901. /*************************  Linear Algebra    *****************************/
  902.  
  903. int    __vf  MFLUdecompose( fPMatrix MLU,  uiVector Ind, fPMatrix MA,
  904.                             unsigned len );
  905.  
  906. void   __vf  MFLUsolve( fVector X, fPMatrix MLU, fVector B, uiVector Ind,
  907.                         unsigned len );
  908. void   __vf  MFLUinv( fPMatrix MInv, fPMatrix MLU, uiVector Ind,
  909.                       unsigned len );
  910. float  __vf  MFLUdet( fPMatrix MLU, unsigned len, int permut );
  911. void   __vf  MFLUimprove( fVector X, fVector B, fPMatrix MA, fPMatrix MLU,
  912.                           uiVector Ind, unsigned len );
  913.  
  914. int   __vf  MFSVdecompose( fPMatrix MU, fPMatrix MV, fVector W, fPMatrix MA,
  915.                            unsigned htA, unsigned lenA );
  916. void  __vf  MFSVsolve( fVector X, fPMatrix MU, fPMatrix MV, fVector W,
  917.                        fVector B, unsigned htU, unsigned lenU );
  918. void  __vf  MFSVimprove(  fVector X, fVector B, fPMatrix MA,
  919.                        fPMatrix MU, fPMatrix MV, fVector W,
  920.                        unsigned htA, unsigned lenA );
  921.  
  922.           /*  functions using LUD or SVD     */
  923. int    __vf  MFsolve( fVector X, fPMatrix MA, fVector B, unsigned len );
  924.                   /* ret.value != 0 signals error */
  925. int    __vf  MFinv( fPMatrix MInv, fPMatrix MA, unsigned len );
  926.                  /* ret.value != 0 signals error */
  927. float  __vf  MFdet( fPMatrix MA, unsigned len );
  928.  
  929. int    __vf  MFsolveBySVD( fVector X, fPMatrix MA, fVector B,
  930.                            unsigned htA, unsigned lenA );
  931.               /*  sizX = lenA,  sizB = htA.  ret.value != 0 signals failure */
  932. int    __vf  MFsafeSolve( fVector X, fPMatrix MA, fVector B, unsigned len );
  933.               /* ret.value 0: success via LUD; 1: success via SVD; -1: error */
  934.  
  935.        /*********  Eigenvalues and Eigenvectors  ********/
  936.  
  937. void __vf MFs_eigenvalues( fVector EigV, fPMatrix EigM, fPMatrix MA, unsigned len,
  938.                         int CalcEigenVec );
  939.  
  940. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  941.  
  942. void  __vf   MFlFFT( fPMatrix MY, fPMatrix MX,
  943.                      unsigned ht, unsigned len, int dir );
  944. void  __vf   MFlconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  945.                           fPMatrix MRsp, unsigned ht, unsigned len );
  946. void  __vf   MFldeconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  947.                             fPMatrix MRsp, unsigned ht, unsigned len );
  948. void  __vf   MFlfilter( fPMatrix MY, fPMatrix MX, fPMatrix MFlt,
  949.                         unsigned ht, unsigned len );
  950. void  __vf   MFlautocorr( fPMatrix MACorr, fPMatrix MX,
  951.                           unsigned ht, unsigned len );
  952. void  __vf   MFlxcorr( fPMatrix MXCorr, fPMatrix MX, fPMatrix MY,
  953.                        unsigned ht, unsigned len );
  954. void  __vf   MFlspectrum( fPMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  955.                           fPMatrix MX, unsigned htX, unsigned lenX,
  956.                           fPMatrix MWin );
  957.  
  958. void  __vf   MFsFFT( fPMatrix MY, fPMatrix MX,
  959.                      unsigned ht, unsigned len, int dir );
  960. void  __vf   MFsconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  961.                           fPMatrix MRsp, unsigned ht, unsigned len );
  962. void  __vf   MFsdeconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  963.                             fPMatrix MRsp, unsigned ht, unsigned len );
  964. void  __vf   MFsfilter( fPMatrix MY, fPMatrix MX, fPMatrix MFlt,
  965.                         unsigned ht, unsigned len );
  966. void  __vf   MFsautocorr( fPMatrix MACorr, fPMatrix MX,
  967.                           unsigned ht, unsigned len );
  968. void  __vf   MFsxcorr( fPMatrix MXCorr, fPMatrix MX, fPMatrix MY,
  969.                        unsigned ht, unsigned len );
  970. void  __vf   MFsspectrum( fPMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  971.                           fPMatrix MX, unsigned htX, unsigned lenX,
  972.                           fPMatrix MWin );
  973.  
  974. /*************************  Data Fitting    *******************************/
  975.  
  976. void __vf VFpolyfitwW( fVector A, fPMatrix Covar, unsigned deg,
  977.                         fVector X, fVector Y, fVector InvVar, ui sizex );
  978. void __vf VFlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  979.                     fVector X, fVector Y, fVector InvVar, ui sizex,
  980.                     void (*funcs)(fVector BasFuncs, float x, unsigned nfuncs) );
  981. float __vf VFnonlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  982.                     fVector X, fVector Y, fVector InvVar, ui sizex,
  983.                     void (*modelfunc)(fVector YModel, fVector X, ui size),
  984.                     void (*derivatives)(fVector dYdAi, fVector X, ui size, unsigned i) );
  985. void __vf MFlinfit( fVector A, iVector AStatus, unsigned npars,
  986.                     fVector X, fVector Y, fPMatrix MZ, unsigned htZ, unsigned lenZ,
  987.                     void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs) );
  988. float __vf MFnonlinfit( fVector A, iVector AStatus, unsigned npars,
  989.                     fVector X, fVector Y, fPMatrix MZ, unsigned htZ, unsigned lenZ,
  990.                     void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ, fVector X, fVector Y ),
  991.                     void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar) );
  992. void __vf MFlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  993.                       fVector X, fVector Y, fPMatrix MZ, fPMatrix MInvVar, unsigned htZ, unsigned lenZ,
  994.                       void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs) );
  995. float __vf MFnonlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  996.                     fVector X, fVector Y, fPMatrix MZ, fPMatrix MInvVar, unsigned htZ, unsigned lenZ,
  997.                     void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ, fVector X, fVector Y ),
  998.                     void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar) );
  999.  
  1000. void __vf VFmultiLinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned ma,
  1001.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1002.                 void (*funcs)(fVector BasFuncs, float x,
  1003.                               unsigned nfuncs, unsigned nexperiment) );
  1004. void __vf MFmultiLinfitwW( fVector A, fPMatrix Covar,
  1005.                 iVector AStatus, unsigned npars,
  1006.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1007.                 void (*funcs)(fVector BasFuncs, float x, float y,
  1008.                               unsigned nfuncs, unsigned nexperiment) );
  1009. float __vf VFmultiNonlinfitwW( fVector A, fPMatrix Covar,
  1010.                 iVector AStatus, unsigned npars,
  1011.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1012.                 void (*modelfunc)(fVector YModel, fVector X, ui size,
  1013.                                   unsigned iexperiment),
  1014.                 void (*derivatives)(fVector dYdAi, fVector X, ui size,
  1015.                                   unsigned ipar, unsigned iexperiment) );
  1016. float __vf MFmultiNonlinfitwW( fVector A, fPMatrix Covar,
  1017.                 iVector AStatus, unsigned npars,
  1018.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1019.                 void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ,
  1020.                                   fVector X, fVector Y, unsigned iexperiment ),
  1021.                 void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  1022.                                     fVector X, fVector Y,
  1023.                                     unsigned ipar, unsigned iexperiment) );
  1024.  
  1025.       /*************  Input and Output  ****************/
  1026.  
  1027. void __vf MFfprint( FILE _VFAR *stream, fPMatrix MA, unsigned ht,
  1028.                      unsigned len, unsigned linewidth );
  1029. #ifndef _Windows
  1030.     void __vf MFcprint( fPMatrix MA, unsigned ht, unsigned len );
  1031. #endif
  1032. void  __vf    MFwrite( FILE _VFAR *stream, fPMatrix X, unsigned ht, unsigned len  );
  1033. void  __vf    MFread( fPMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  1034.  
  1035. #ifdef __cplusplus
  1036. }
  1037. #endif
  1038. #endif 
  1039.